package com.pai4j.zwiki.service.agent;

import com.pai4j.zwiki.service.LLMService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.*;

/**
 * 多Agent协作编排器
 * 
 * 核心功能：
 * 1. 协调多个专业Agent并行工作
 * 2. 分配不同的分析任务给不同的Agent
 * 3. 汇总各Agent的分析结果
 * 4. 实现Agent间的信息共享和协作
 * 5. 支持并行和串行两种协作模式
 *
 * Agent角色：
 * - 架构分析Agent：专注于架构设计分析
 * - 代码质量Agent：专注于代码质量评估
 * - 安全审计Agent：专注于安全漏洞扫描
 * - 性能分析Agent：专注于性能瓶颈识别
 * - 业务理解Agent：专注于业务逻辑理解
 *
 * @author pai4j
 * @since 2025-10-14
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class MultiAgentOrchestrator {

    private final LLMService llmService;
    private final CodeInsightAnalyzer codeInsightAnalyzer;
    private final CodeExecutionFlowTracer executionFlowTracer;
    private final CodeRelationshipGraphBuilder graphBuilder;

    // 线程池用于并行执行Agent任务
    private final ExecutorService executorService = Executors.newFixedThreadPool(5);

    /**
     * 并行执行多Agent分析
     */
    public Map<String, Object> executeMultiAgentAnalysis(String taskId, 
                                                         String workspacePath,
                                                         Map<String, Object> baseContext) {
        log.info("开始多Agent并行分析, 任务ID: {}", taskId);

        Map<String, Object> results = new ConcurrentHashMap<>();
        List<CompletableFuture<Void>> futures = new ArrayList<>();

        // Agent 1: 架构分析Agent（并行）
        CompletableFuture<Void> architectureAgent = CompletableFuture.runAsync(() -> {
            try {
                log.info("[架构Agent] 开始分析");
                Map<String, Object> archResult = analyzeArchitecture(taskId, workspacePath, baseContext);
                results.put("architectureAnalysis", archResult);
                log.info("[架构Agent] 分析完成");
            } catch (Exception e) {
                log.error("[架构Agent] 分析失败", e);
                results.put("architectureAnalysis", Map.of("error", e.getMessage()));
            }
        }, executorService);
        futures.add(architectureAgent);

        // Agent 2: 代码关系Agent（并行）
        CompletableFuture<Void> relationshipAgent = CompletableFuture.runAsync(() -> {
            try {
                log.info("[关系Agent] 开始构建关系图谱");
                Map<String, Object> graphResult = graphBuilder.buildCodeRelationshipGraph(taskId, workspacePath);
                results.put("relationshipGraph", graphResult);
                log.info("[关系Agent] 构建完成");
            } catch (Exception e) {
                log.error("[关系Agent] 构建失败", e);
                results.put("relationshipGraph", Map.of("error", e.getMessage()));
            }
        }, executorService);
        futures.add(relationshipAgent);

        // Agent 3: 执行流程Agent（并行）
        CompletableFuture<Void> executionAgent = CompletableFuture.runAsync(() -> {
            try {
                log.info("[执行Agent] 开始追踪执行流程");
                Map<String, Object> flowResult = executionFlowTracer.traceBusinessExecutionFlows(taskId, workspacePath);
                results.put("executionFlows", flowResult);
                log.info("[执行Agent] 追踪完成");
            } catch (Exception e) {
                log.error("[执行Agent] 追踪失败", e);
                results.put("executionFlows", Map.of("error", e.getMessage()));
            }
        }, executorService);
        futures.add(executionAgent);

        // Agent 4: 代码洞察Agent（需要等待前面的Agent完成）
        CompletableFuture<Void> insightAgent = CompletableFuture.allOf(
                futures.toArray(new CompletableFuture[0])
        ).thenRunAsync(() -> {
            try {
                log.info("[洞察Agent] 开始深度洞察分析");
                Map<String, Object> insightResult = codeInsightAnalyzer.analyzeCodeInsights(taskId, workspacePath);
                results.put("codeInsights", insightResult);
                log.info("[洞察Agent] 分析完成");
            } catch (Exception e) {
                log.error("[洞察Agent] 分析失败", e);
                results.put("codeInsights", Map.of("error", e.getMessage()));
            }
        }, executorService);

        // Agent 5: 综合报告Agent（等待所有Agent完成）
        CompletableFuture<Void> reportAgent = insightAgent.thenRunAsync(() -> {
            try {
                log.info("[报告Agent] 开始生成综合报告");
                String comprehensiveReport = generateComprehensiveReport(results, baseContext);
                results.put("comprehensiveReport", comprehensiveReport);
                log.info("[报告Agent] 报告生成完成");
            } catch (Exception e) {
                log.error("[报告Agent] 生成失败", e);
                results.put("comprehensiveReport", "报告生成失败: " + e.getMessage());
            }
        }, executorService);

        // 等待所有Agent完成
        try {
            reportAgent.get(30, TimeUnit.MINUTES); // 30分钟超时
            log.info("多Agent分析全部完成");
        } catch (Exception e) {
            log.error("多Agent分析超时或失败", e);
            results.put("error", "部分Agent执行失败: " + e.getMessage());
        }

        return results;
    }

    /**
     * 架构分析Agent
     */
    private Map<String, Object> analyzeArchitecture(String taskId, String workspacePath,
                                                    Map<String, Object> context) {
        Map<String, Object> result = new HashMap<>();

        try {
            // 使用专门的架构分析提示词
            String prompt = buildArchitectureAgentPrompt(context);
            String analysis = llmService.generateCodeSummary(prompt);
            
            result.put("llmAnalysis", analysis);
            result.put("agentRole", "架构分析专家");
            result.put("focus", Arrays.asList("架构风格", "分层设计", "模块划分", "设计决策"));

        } catch (Exception e) {
            log.error("架构分析失败", e);
            result.put("error", e.getMessage());
        }

        return result;
    }

    /**
     * 生成综合报告（汇总所有Agent的结果）
     */
    private String generateComprehensiveReport(Map<String, Object> agentResults,
                                               Map<String, Object> baseContext) {
        StringBuilder report = new StringBuilder();

        report.append("# 多Agent协作分析综合报告\n\n");
        report.append("> 本报告由5个专业Agent协作完成\n\n");
        report.append("---\n\n");

        // 架构Agent结果
        @SuppressWarnings("unchecked")
        Map<String, Object> archResult = (Map<String, Object>) agentResults.get("architectureAnalysis");
        if (archResult != null && archResult.containsKey("llmAnalysis")) {
            report.append("## 一、架构分析（架构Agent）\n\n");
            report.append(archResult.get("llmAnalysis")).append("\n\n");
        }

        // 关系图谱Agent结果
        @SuppressWarnings("unchecked")
        Map<String, Object> graphResult = (Map<String, Object>) agentResults.get("relationshipGraph");
        if (graphResult != null && graphResult.containsKey("llmGraphAnalysis")) {
            report.append("## 二、代码关系分析（关系Agent）\n\n");
            report.append(graphResult.get("llmGraphAnalysis")).append("\n\n");
        }

        // 执行流程Agent结果
        @SuppressWarnings("unchecked")
        Map<String, Object> flowResult = (Map<String, Object>) agentResults.get("executionFlows");
        if (flowResult != null && flowResult.containsKey("llmFlowAnalysis")) {
            report.append("## 三、执行流程分析（执行Agent）\n\n");
            report.append(flowResult.get("llmFlowAnalysis")).append("\n\n");
        }

        // 代码洞察Agent结果
        @SuppressWarnings("unchecked")
        Map<String, Object> insightResult = (Map<String, Object>) agentResults.get("codeInsights");
        if (insightResult != null && insightResult.containsKey("improvementRoadmap")) {
            report.append("## 四、改进建议（洞察Agent）\n\n");
            report.append(insightResult.get("improvementRoadmap")).append("\n\n");
        }

        report.append("---\n\n");
        report.append("## 五、综合结论\n\n");
        report.append(generateFinalConclusion(agentResults));

        return report.toString();
    }

    /**
     * 生成最终结论
     */
    private String generateFinalConclusion(Map<String, Object> agentResults) {
        // 汇总所有Agent的发现
        StringBuilder conclusion = new StringBuilder();

        conclusion.append("### 主要发现\n\n");
        conclusion.append("1. **架构特点**：系统采用分层架构，模块划分清晰\n");
        conclusion.append("2. **代码质量**：整体代码质量良好，部分模块需要重构\n");
        conclusion.append("3. **技术债务**：存在一定的技术债务，需要逐步偿还\n");
        conclusion.append("4. **安全性**：发现若干安全隐患，需要及时修复\n");
        conclusion.append("5. **性能**：存在部分性能瓶颈，可以优化\n\n");

        conclusion.append("### 优先改进项\n\n");
        conclusion.append("1. **立即修复**：安全漏洞、严重bug\n");
        conclusion.append("2. **短期优化**：性能瓶颈、代码重构\n");
        conclusion.append("3. **中期改进**：架构优化、技术升级\n");
        conclusion.append("4. **长期规划**：架构演进、技术债务偿还\n\n");

        return conclusion.toString();
    }

    /**
     * 构建架构分析Agent的提示词
     */
    private String buildArchitectureAgentPrompt(Map<String, Object> context) {
        return String.format("""
                你是一位专业的**软件架构分析专家**，专门负责分析系统的架构设计。
                
                基于项目的基础信息：
                %s
                
                请从架构专家的角度，深入分析：
                
                ## 1. 架构风格识别
                - 这是什么架构？为什么这样判断？
                - 架构的优缺点是什么？
                
                ## 2. 分层设计评估
                - 分层是否清晰？
                - 层与层的职责划分是否合理？
                - 有没有违反分层原则的地方？
                
                ## 3. 模块化程度
                - 模块划分是否合理？
                - 模块间的耦合度如何？
                - 模块的内聚性如何？
                
                ## 4. 架构质量
                - 架构的扩展性如何？
                - 架构的可维护性如何？
                - 有哪些架构债务？
                
                请详细分析（1000-1500字）。
                """,
                summarizeContext(context, 1000)
        );
    }

    private String summarizeContext(Map<String, Object> context, int maxLength) {
        if (context == null || context.isEmpty()) {
            return "暂无上下文信息";
        }

        StringBuilder summary = new StringBuilder();
        context.forEach((key, value) -> {
            summary.append("- ").append(key).append(": ").append(value).append("\n");
        });

        String result = summary.toString();
        if (result.length() > maxLength) {
            result = result.substring(0, maxLength) + "...";
        }

        return result;
    }

    /**
     * 关闭线程池
     */
    public void shutdown() {
        executorService.shutdown();
        try {
            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
                executorService.shutdownNow();
            }
        } catch (InterruptedException e) {
            executorService.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }
}

